#define SUPPRESS_COMPILER_INLINES
#include "std.h"
#include "lpc_incl.h"
#include "scratchpad.h"
#include "compiler.h"

/*
 * This is a first attempt at beating malloc() for allocation of strings
 * during compilation.  It's pretty general, and could probably be done
 * better.
 * 
 * Here's what we can assume:
 * Things are going to conform to LIFO order, more or less.
 * Strings will be of the long variety and the short variety.
 * A realloc on strings might be nice, for "a" "b" "c" ... etc
 * 
 * Although in rare cases (errors) certain items won't come off until the
 * table is destroyed.
 */
/* Here is what is currently being used:
 *
 * <0> <0> string1 <len1> string2 <len2>
 *                        ^          ^
 *                        last      tail
 *
 * len1 is the length of string1 including the zero at the end
 *
 * Note: "" looks a heck of a lot like a interior freed string.  Currently,
 * we ignore the problem.  In some cases, it could be left dangling, but
 * I don't think that can happen with the present grammar/use of the
 * scratchpad.
 */
/*
 *  Todo: This algorithm might be faster if we aligned to 2 byte
 *  boundaries and used shorts for lengths.  We wouldn't have to
 *  worry about the 256 byte limit then
 */
/*
 * Within this file, a capitalized identifier is that var cast to an
 * unsigned type.  It makes things easier to read than having casts
 * all over the place since we go back and forth a lot.  strict ANSI
 * requires casts from (unsigned char *) to (char *) and back, but
 * we want to deal with strings as unsigned since we keep the length
 * in them.
 */
#define Str ((unsigned char *)str)
#define Ptr ((unsigned char *)ptr)
#define Res ((unsigned char *)res)
#define S1 ((unsigned char *)s1)
#define S2 ((unsigned char *)s2)
#define Scratch_large_alloc(x) ((unsigned char *)scratch_large_alloc(x))
#define Strlen(x) (strlen((char *)x))
#define Strcpy(x, y) (strcpy((char *)x, (char *)y))
#define Strncpy(x, y, z) (strncpy((char *)x, (char *)y, z))

/* not strictly ANSI, but should always work ... */
#define HDR_SIZE ((char *)&scratch_head.block[2] - (char *)&scratch_head)
#define FIND_HDR(x) ((sp_block_t *)(x - HDR_SIZE))
#define SIZE_WITH_HDR(x) (x + HDR_SIZE)

static unsigned char scratchblock[SCRATCHPAD_SIZE];
static sp_block_t scratch_head = { 0, 0 };
unsigned char *scr_last = &scratchblock[2], *scr_tail = &scratchblock[2];
unsigned char *scratch_end = scratchblock + SCRATCHPAD_SIZE;

#if 0
static void scratch_summary(void);

static void scratch_summary()
{
	unsigned char *p = scratchblock;
	int i;

	while (p<=scr_tail)
	{
		if (*p == 0) printf("0");
		else if (*p < 32 || *p > 127) printf("*");
		else printf("%c", *p);
		p++;
	}
	printf("\n");
	i = scr_last - scratchblock;
	while (i--) printf(" ");
	printf("l\n");
	i = scr_tail - scratchblock;
	while (i--) printf(" ");
	printf("t\n");
}
#endif

void scratch_destroy()
{
	sp_block_t *next, *this = scratch_head.next;

	SDEBUG(printf("scratch_destroy\n"));

	while (this)
	{
		next = this->next;
		FREE(this);
		this = next;
	}
	scratch_head.next = 0;
	scr_last = &scratchblock[2];
	scr_tail = &scratchblock[2];
}

char *scratch_copy(char * str)
{
	unsigned char *from, *to, *end;

	SDEBUG2(printf("scratch_copy(%s):", str));

	/* first, take a wild guess that there is room and save a strlen() :) */
	from = Str;
	to = scr_tail + 1;
	end = scratch_end - 2; /* room for zero and len */
	if (end > to + 255)
		end = to + 255;
	while (*from && to < end)
		*to++ = *from++;
	if (!(*from))
	{
		SDEBUG2(printf(" on scratchpad\n"));

		scr_last = scr_tail + 1;
		*to++ = 0;
		scr_tail = to;
		*to = to - scr_last;
		return (char *) scr_last;
	}SDEBUG(printf(" mallocing ... "));

	/* ACK! no room. strlen(str) == (from - str) + strlen(from) */
	to = Scratch_large_alloc((from - Str) + Strlen(from) + 1);
	Strcpy(to, str);
	return (char *) to;
}

void scratch_free(char * ptr)
{
	/* how do we know what this is?  first we check if it's the last string
	 we made.  Otherwise, take advantage of the fact that things on the
	 scratchpad have a zero two before them.  Things not on it wont
	 (we make sure of this) */

	SDEBUG2(printf("scratch_free(%s): ", ptr));

	if (Ptr == scr_last)
	{
		SDEBUG2(printf("last freed\n"));
		scratch_free_last();
	}
	else if (*(Ptr - 2))
	{
		sp_block_t *sbt;

		DEBUG_CHECK(*(Ptr - 2) != SCRATCH_MAGIC, "scratch_free called on non-scratchpad string.\n");SDEBUG(printf("block freed\n"));
		sbt = FIND_HDR(ptr);
		if (sbt->prev)
			sbt->prev->next = sbt->next;
		if (sbt->next)
			sbt->next->prev = sbt->prev;
		FREE(sbt);
	}
	else
	{
		SDEBUG(printf("interior free\n"));
		*ptr = 0; /* mark it as freed */
	}
}

char *scratch_large_alloc(int size)
{
	sp_block_t *spt;

	SDEBUG(printf("scratch_large_alloc(%i)\n", size));

	spt =
	        (sp_block_t *) DMALLOC(SIZE_WITH_HDR(size), TAG_COMPILER, "scratch_alloc");
	if ((spt->next = scratch_head.next))
		spt->next->prev = spt;
	spt->prev = (sp_block_t *) &scratch_head;
	spt->block[0] = SCRATCH_MAGIC;
	scratch_head.next = spt;
	return (char *) &spt->block[2];
}

/* warning: unlike REALLOC(), this one only allows increases */
char *scratch_realloc(char * ptr, int size)
{
	SDEBUG(printf("scratch_realloc(%s): ", ptr));

	if (Ptr == scr_last)
	{
		if (size < 256 && (scr_last + size) < scratch_end)
		{
			SDEBUG(printf("on scratchpad\n"));
			scr_tail = scr_last + size;
			*scr_tail = size;
			return ptr;
		}
		else
		{
			char *res;
			SDEBUG(printf("copy off ... "));
			res = scratch_large_alloc(size);
			strcpy(res, ptr);
			scratch_free_last();
			return res;
		}
	}
	else if (*(Ptr - 2))
	{
		sp_block_t *sbt, *newsbt;

		DEBUG_CHECK(*(Ptr - 2) != SCRATCH_MAGIC, "scratch_realloc on non-scratchpad string.\n");SDEBUG(printf("block\n"));
		sbt = FIND_HDR(ptr);
		newsbt = (sp_block_t *) DREALLOC(sbt, SIZE_WITH_HDR(size),
				TAG_COMPILER, "scratch_realloc");
		newsbt->prev->next = newsbt;
		if (newsbt->next)
			newsbt->next->prev = newsbt;
		return (char *) &newsbt->block[2];
	}
	else
	{
		char *res;

		SDEBUG(printf("interior ... "));
		/* ACK!! it's in the middle. */
		if (size < 256 && (scr_tail + size + 1) < scratch_end)
		{
			SDEBUG(printf("move to end\n"));
			scr_last = scr_tail + 1;
			Strcpy(scr_last, ptr);
			scr_tail = scr_last + size;
			*scr_tail = size;
			res = (char *) scr_last;
		}
		else
		{
			SDEBUG(printf("copy off ... "));
			res = scratch_large_alloc(size);
			strcpy(res, ptr);
		}
		*ptr = 0; /* free the old version */
		return res;
	}
}

/* the routines above are better than this */
char *scratch_alloc(int size)
{
	SDEBUG(printf("scratch_alloc(%i)\n", size));
	if (size < 256 && (scr_tail + size + 1) < scratch_end)
	{
		scr_last = scr_tail + 1;
		scr_tail = scr_last + size;
		*scr_tail = size;
		return (char *) scr_last;
	}
	else
		return scratch_large_alloc(size);
}

char *scratch_join(char * s1, char * s2)
{
	char *res;
	int tmp;

	SDEBUG(printf("scratch_join\n"));
	if (*(s1 - 2) || *(s2 - 2))
	{
		int l = strlen(s1);

		DEBUG_CHECK(*(S1 - 2) && *(S1 - 2) != SCRATCH_MAGIC, "argument 1 to scratch_join was not a scratchpad string.\n");DEBUG_CHECK(*(S2 - 2) && *(S2 - 2) != SCRATCH_MAGIC, "argument 2 to scratch_join was not a scratchpad string.\n");

		res = scratch_realloc(s1, l + strlen(s2) + 1);
		strcpy(res + l, s2);
		scratch_free(s2);
		return res;
	}
	else
	{
		/* This assumes that S1 and S2 were the last two things allocated.
		 Make sure this is true */
		DEBUG_CHECK(S2 != scr_last, "Argument 2 to scratch_join was not the last allocated string.\n");DEBUG_CHECK(S1 != (scr_last - 1 - (*(scr_last - 1))), "Argument 1 to scratch_join was not the second to last allocated string.\n");

		if ((tmp = ((scr_tail - S1) - 2)) < 256)
		{
			scr_tail = scr_last - 2;
			do
			{
				*scr_tail = *(scr_tail + 2);
			}
			while (*scr_tail++);
			*scr_tail = tmp;
			scr_last = S1;
			return s1;
		}
		else
		{
			char *ret = scratch_large_alloc(tmp);
			strcpy(ret, s1);
			strcpy(ret + (scr_last - S1) - 2, s2);
			scratch_free(s1);
			scratch_free(s2);
			return ret;
		}
	}
}

char *scratch_copy_string(char * s)
{
	int l;
	register unsigned char *to = scr_tail + 1;
	char *res;

	SDEBUG2(printf("scratch_copy_string\n"));
	l = scratch_end - to;

	if (l > 255)
		l = 255;
	s++;
	while (l--)
	{
		if (*s == '\\')
		{
			switch (*++s)
			{
				case 'n':
					*to++ = '\n';
					break;
				case 't':
					*to++ = '\t';
					break;
				case 'r':
					*to++ = '\r';
					break;
				case 'b':
					*to++ = '\b';
					break;
				case '"':
				case '\\':
					*to++ = *s;
					break;
				default:
					*to++ = *s;
					yywarn("Unknown \\x char.");
			}
			s++;
		}
		else if (*s == '"')
		{
			*to++ = 0;
			if (!l && (to == scratch_end))
			{
				res = scratch_large_alloc(to - scr_tail - 1);
				Strcpy(res, scr_tail + 1);
				return res;
			}
			scr_last = scr_tail + 1;
			scr_tail = to;
			*to = to - scr_last;
			return (char *) scr_last;
		}
		else
			*to++ = *s++;
	}
	/* estimate the length we need */
	/* Note that the last char is we read is ", not \0 - Sym */
	res = scratch_large_alloc(to - scr_tail + strlen(s) - 1);
	Strncpy(res, (scr_tail + 1), (to - scr_tail) - 1);
	to = Res + (to - scr_tail) - 1;
	for (;;)
	{
		if (*s == '\\')
		{
			switch (*++s)
			{
				case 'n':
					*to++ = '\n';
					break;
				case 't':
					*to++ = '\t';
					break;
				case 'r':
					*to++ = '\r';
					break;
				case 'b':
					*to++ = '\b';
					break;
				case '"':
				case '\\':
					*to++ = *s;
					break;
				default:
					*to++ = *s;
					yywarn("Unknown \\x char.");
			}
			s++;
		}
		else if (*s == '"')
		{
			*to++ = 0;
			return res;
		}
		else
			*to++ = *s++;
	}
}

